home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / strategy / xpuzzles.3 / xpuzzles / xpuzzles-5.3.1 / xdino / xmdino.c < prev   
C/C++ Source or Header  |  1996-04-02  |  18KB  |  604 lines
  1. /*
  2. # MOTIF-BASED DINOSAUR CUBE
  3. #
  4. #  xmdino.c
  5. #
  6. ###
  7. #
  8. #  Copyright (c) 1995 - 96    David Albert Bagley, bagleyd@hertz.njit.edu
  9. #
  10. #                   All Rights Reserved
  11. #
  12. #  Permission to use, copy, modify, and distribute this software and
  13. #  its documentation for any purpose and without fee is hereby granted,
  14. #  provided that the above copyright notice appear in all copies and
  15. #  that both that copyright notice and this permission notice appear in
  16. #  supporting documentation, and that the name of the author not be
  17. #  used in advertising or publicity pertaining to distribution of the
  18. #  software without specific, written prior permission.
  19. #
  20. #  This program is distributed in the hope that it will be "playable",
  21. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  23. #
  24. */
  25.  
  26. /*
  27.   Version 5: 95/10/06 Xt/Motif
  28.   Version 4: 94/05/30 Xt
  29. */
  30.  
  31. #include <stdlib.h>
  32. #include <stdio.h>
  33. #ifdef VMS
  34. #include <unixlib.h>
  35. #define getlogin cuserid
  36. #else
  37. #ifndef apollo
  38. #include <unistd.h>
  39. #endif
  40. #endif
  41. #include <X11/Intrinsic.h>
  42. #include <X11/StringDefs.h>
  43. #include <X11/Shell.h>
  44. #include <X11/cursorfont.h>
  45. #include <Xm/PanedW.h>
  46. #include <Xm/RowColumn.h>
  47. #include <Xm/Label.h>
  48. #include <Xm/LabelG.h>
  49. #include <Xm/Scale.h>
  50. #include <Xm/ToggleB.h>
  51. #include <Xm/ToggleBG.h>
  52. #include "Dino.h"
  53. #include "Dino2d.h"
  54. #include "Dino3d.h"
  55. #include "dino.xbm"
  56. #include "mouse-l.xbm"
  57. #include "mouse-r.xbm"
  58.  
  59. #ifndef SCOREFILE
  60. #define SCOREFILE "/usr/games/lib/dino.scores"
  61. #endif
  62.  
  63. /* The following are in DinoP.h also */
  64. #define PERIOD2 2
  65. #define PERIOD3 3
  66. #define BOTH 4
  67. #define MAXMODES 3
  68. #define MAXFACES 6
  69.  
  70. #define MAXRECORD 32767
  71.  
  72. static void Initialize();
  73. static void CallbackDino();
  74.  
  75. static void PrintRecord();
  76. static int HandleSolved();
  77. static void ReadRecords();
  78. static void WriteRecords();
  79.  
  80. static void ModeToggle();
  81. static void OrientToggle();
  82. static void PracticeToggle();
  83. static void motif_printf();
  84.  
  85. static Arg arg[5];
  86. static Widget moves, record, message, dino2d, dino3d, modes[MAXMODES],
  87.   orientSwitch, practiceSwitch;
  88. static int dinoRecord[MAXMODES][2], movesDsp = 0;
  89. static char messageDsp[128] = "Welcome";
  90.  
  91. static char *modeString[] = {
  92.   "Period 2", "Period 3", "Both"
  93. };
  94.  
  95. static void Usage()
  96. {
  97.   (void) fprintf(stderr, "usage: xmdino\n");
  98.   (void) fprintf(stderr, 
  99.     "\t[-geometry [{width}][x{height}][{+-}{xoff}[{+-}{yoff}]]]\n");
  100.   (void) fprintf(stderr, 
  101.     "\t[-display [{host}]:[{vs}]][-fg {color}] [-bg {color}]\n");
  102.   (void) fprintf(stderr,
  103.     "\t[-{border|bd} {color}] [-mono] [-{mode {int} | both}] [-[no]orient]\n");
  104.    (void) fprintf(stderr,
  105.     "\t-[no]practice] [-face{0|1|2|3|4|5} {color}]\n");
  106.   exit(1);
  107. }
  108.  
  109. static XrmOptionDescRec options[] = {
  110.   {"-fg",        "*dino.Foreground",    XrmoptionSepArg,    NULL},
  111.   {"-bg",        "*Background",        XrmoptionSepArg,    NULL},
  112.   {"-foreground",    "*dino.Foreground",    XrmoptionSepArg,    NULL},
  113.   {"-background",    "*Background",        XrmoptionSepArg,    NULL},
  114.   {"-border",           "*dino.pieceBorder",    XrmoptionSepArg,        NULL},
  115.   {"-bd",               "*dino.pieceBorder",    XrmoptionSepArg,        NULL},
  116.   {"-mono",        "*dino.mono",        XrmoptionNoArg,        "TRUE"},
  117.   {"-mode",        "*dino.mode",        XrmoptionSepArg,    NULL},
  118.   {"-both",        "*dino.mode",        XrmoptionNoArg,        "4"},
  119.   {"-orient",        "*dino.orient",        XrmoptionNoArg,        "TRUE"},
  120.   {"-noorient",        "*dino.orient",        XrmoptionNoArg,        "FALSE"},
  121.   {"-practice",        "*dino.practice",    XrmoptionNoArg,        "TRUE"},
  122.   {"-nopractice",    "*dino.practice",    XrmoptionNoArg,        "FALSE"},
  123.   {"-face0",        "*dino.faceColor0",    XrmoptionSepArg,    NULL},
  124.   {"-face1",        "*dino.faceColor1",    XrmoptionSepArg,    NULL},
  125.   {"-face2",        "*dino.faceColor2",    XrmoptionSepArg,    NULL},
  126.   {"-face3",        "*dino.faceColor3",    XrmoptionSepArg,    NULL},
  127.   {"-face4",        "*dino.faceColor4",    XrmoptionSepArg,    NULL},
  128.   {"-face5",        "*dino.faceColor5",    XrmoptionSepArg,    NULL},
  129. };
  130.  
  131. int main(argc, argv)
  132.   int argc;
  133.   char *argv[];
  134. {
  135.   Widget toplevel;
  136.   Widget panel, panel2, rowcol, rowcol2, rowcol3;
  137.   Pixmap mouseLeftCursor, mouseRightCursor;
  138.   Pixel fg, bg;
  139.   int i;
  140.  
  141.   toplevel = XtInitialize(argv[0], "Dino",
  142.     options, XtNumber(options), &argc, argv);
  143.   if (argc != 1)
  144.     Usage();
  145.  
  146.   XtSetArg(arg[0], XtNiconPixmap,
  147.     XCreateBitmapFromData(XtDisplay(toplevel),
  148.       RootWindowOfScreen(XtScreen(toplevel)),
  149.       (char *) dino_bits, dino_width, dino_height));
  150.   XtSetArg(arg[1], XmNkeyboardFocusPolicy, XmPOINTER); /* not XmEXPLICIT */    
  151.   XtSetValues(toplevel, arg, 2);    
  152.   panel = XtCreateManagedWidget("panel", xmPanedWindowWidgetClass, toplevel,
  153.     NULL, 0);
  154.   panel2 = XtVaCreateManagedWidget("panel2", xmPanedWindowWidgetClass, panel,
  155.     XmNseparatorOn, False,
  156.     XmNsashWidth, 1,
  157.     XmNsashHeight, 1,
  158.     NULL);
  159.  
  160.   rowcol = XtVaCreateManagedWidget("Rowcol", xmRowColumnWidgetClass, panel2,
  161.     XmNnumColumns, 2,
  162.     XmNorientation, XmHORIZONTAL,
  163.     XmNpacking, XmPACK_COLUMN,
  164.     NULL);
  165.   XtVaGetValues(rowcol, XmNforeground, &fg, XmNbackground, &bg, NULL);
  166.   mouseLeftCursor = XCreatePixmapFromBitmapData(XtDisplay(rowcol),
  167.     RootWindowOfScreen(XtScreen(rowcol)), mouse_left_bits,
  168.     mouse_left_width, mouse_left_height, fg, bg,
  169.     DefaultDepthOfScreen(XtScreen(rowcol)));
  170.   mouseRightCursor = XCreatePixmapFromBitmapData(XtDisplay(rowcol),
  171.     RootWindowOfScreen(XtScreen(rowcol)), mouse_right_bits,
  172.     mouse_right_width, mouse_right_height, fg, bg,
  173.     DefaultDepthOfScreen(XtScreen(rowcol)));
  174.   XtVaCreateManagedWidget("mouseLeftText", xmLabelGadgetClass, rowcol,
  175.     XtVaTypedArg, XmNlabelString, XmRString, "Move", 5, NULL);
  176.   XtVaCreateManagedWidget("mouseLeft", xmLabelGadgetClass, rowcol,
  177.     XmNlabelType, XmPIXMAP, XmNlabelPixmap, mouseLeftCursor, NULL);
  178.   XtVaCreateManagedWidget("mouseRightText", xmLabelGadgetClass, rowcol,
  179.     XtVaTypedArg, XmNlabelString, XmRString, "Randomize", 10, NULL);
  180.   XtVaCreateManagedWidget("mouseRight", xmLabelGadgetClass, rowcol,
  181.     XmNlabelType, XmPIXMAP, XmNlabelPixmap, mouseRightCursor, NULL);
  182.   XtVaCreateManagedWidget("movesText", xmLabelGadgetClass, rowcol,
  183.     XtVaTypedArg, XmNlabelString, XmRString, "Moves", 6, NULL);
  184.   moves = XtVaCreateManagedWidget("0", xmLabelWidgetClass, rowcol, NULL);
  185.   XtVaCreateManagedWidget("recordText", xmLabelGadgetClass, rowcol,
  186.     XtVaTypedArg, XmNlabelString, XmRString, "Record", 7, NULL);
  187.   record = XtVaCreateManagedWidget("0", xmLabelWidgetClass, rowcol, NULL);
  188.  
  189.   rowcol2 = XtVaCreateManagedWidget("Rowcol2", xmRowColumnWidgetClass, panel2,
  190.     XmNnumColumns, 1,
  191.     XmNorientation, XmHORIZONTAL,
  192.     XmNpacking, XmPACK_COLUMN,
  193.     XmNradioBehavior, True,
  194.     NULL);
  195.   for (i = 0; i < XtNumber(modeString); i++) {
  196.     modes[i] = XtVaCreateManagedWidget(modeString[i],
  197.       xmToggleButtonGadgetClass, rowcol2,
  198.       XmNradioBehavior, True,
  199.       NULL);
  200.     XtAddCallback(modes[i], XmNvalueChangedCallback, ModeToggle,
  201.       (XtPointer) i);
  202.   }
  203.  
  204.   rowcol3 = XtVaCreateManagedWidget("Rowcol3", xmRowColumnWidgetClass, panel2,
  205.     XmNnumColumns, 1,
  206.     XmNorientation, XmHORIZONTAL,
  207.     XmNpacking, XmPACK_COLUMN,
  208.     NULL);
  209.   orientSwitch = XtVaCreateManagedWidget ("Orient",
  210.     xmToggleButtonWidgetClass, rowcol3,
  211.     NULL);
  212.   XtAddCallback(orientSwitch, XmNvalueChangedCallback, OrientToggle, NULL);
  213.   practiceSwitch = XtVaCreateManagedWidget ("Practice",
  214.     xmToggleButtonWidgetClass, rowcol3,
  215.     NULL);
  216.   XtAddCallback(practiceSwitch, XmNvalueChangedCallback, PracticeToggle, NULL);
  217.   message = XtVaCreateManagedWidget("Play Dino! (use mouse and keypad)",
  218.     xmLabelWidgetClass, rowcol3,
  219.     NULL);
  220.  
  221.   dino2d = XtCreateManagedWidget("dino", dino2dWidgetClass, panel,
  222.     NULL, 0);
  223.   XtVaSetValues(dino2d,
  224.     XtNheight, 200,
  225.     NULL);
  226.   XtAddCallback(dino2d, XtNselectCallback, CallbackDino, NULL);
  227.   dino3d = XtCreateManagedWidget("dino", dino3dWidgetClass, panel,
  228.     NULL, 0);
  229.   XtVaSetValues(dino3d,
  230.     XtNheight, 200,
  231.     NULL);
  232.   XtAddCallback(dino3d, XtNselectCallback, CallbackDino, NULL);
  233.   Initialize();
  234.   XtRealizeWidget(toplevel);
  235.   XGrabButton(XtDisplay(dino2d), AnyButton, AnyModifier, XtWindow(dino2d),
  236.     TRUE, ButtonPressMask | ButtonMotionMask | ButtonReleaseMask,
  237.     GrabModeAsync, GrabModeAsync, XtWindow(dino2d),
  238.     XCreateFontCursor(XtDisplay(dino2d), XC_crosshair));
  239.   XGrabButton(XtDisplay(dino3d), AnyButton, AnyModifier, XtWindow(dino3d),
  240.     TRUE, ButtonPressMask | ButtonMotionMask | ButtonReleaseMask,
  241.     GrabModeAsync, GrabModeAsync, XtWindow(dino3d),
  242.     XCreateFontCursor(XtDisplay(dino3d), XC_crosshair));
  243.   XtMainLoop();
  244.  
  245. #ifdef VMS
  246.   return 1;
  247. #else
  248.   return 0;
  249. #endif
  250. }
  251.  
  252. /* There's probably a better way to assure that they are the same but
  253.    I don't know it off hand. */
  254. static void MakeEquivalent(mode, orient, practice)
  255.   int *mode;
  256.   Boolean *orient, *practice;
  257. {
  258.   Boolean mono;
  259.   Pixel foreground, background, pieceBorder;
  260.   String faceColor[MAXFACES];
  261.  
  262.   XtVaGetValues(dino2d,
  263.     XtNmode, mode,
  264.     XtNorient, orient,
  265.     XtNpractice, practice,
  266.     XtNmono, &mono,
  267.     XtNforeground, &foreground,
  268.     XtNbackground, &background,
  269.     XtNpieceBorder, &pieceBorder,
  270.     XtNfaceColor0, &(faceColor[0]),
  271.     XtNfaceColor1, &(faceColor[1]),
  272.     XtNfaceColor2, &(faceColor[2]),
  273.     XtNfaceColor3, &(faceColor[3]),
  274.     XtNfaceColor4, &(faceColor[4]),
  275.     XtNfaceColor5, &(faceColor[5]),
  276.     NULL);
  277.   XtVaSetValues(dino2d,
  278.     XtNdirection, DINO_IGNORE,
  279.     XtNstart, FALSE,
  280.     NULL);
  281.   XtVaSetValues(dino3d,
  282.     XtNmode, *mode,
  283.     XtNorient, *orient,
  284.     XtNpractice, *practice,
  285.     XtNmono, mono,
  286.     XtNdirection, DINO_IGNORE,
  287.     XtNstart, FALSE,
  288.     XtNforeground, foreground,
  289.     XtNbackground, background,
  290.     XtNpieceBorder, pieceBorder,
  291.     XtNfaceColor0, faceColor[0],
  292.     XtNfaceColor1, faceColor[1],
  293.     XtNfaceColor2, faceColor[2],
  294.     XtNfaceColor3, faceColor[3],
  295.     XtNfaceColor4, faceColor[4],
  296.     XtNfaceColor5, faceColor[5],
  297.     NULL);
  298. }
  299.  
  300. static void Initialize()
  301. {
  302.   int mode;
  303.   Boolean orient, practice;
  304.  
  305.   MakeEquivalent(&mode, &orient, &practice);
  306.   ReadRecords();
  307.   XmToggleButtonSetState(modes[mode - PERIOD2], True, False);
  308.   XmToggleButtonSetState(orientSwitch, orient, True);
  309.   XmToggleButtonSetState(practiceSwitch, practice, True);
  310.   PrintRecord(mode, orient, practice);
  311. }
  312.  
  313. static void CallbackDino(w, clientData, callData)
  314.   Widget w;
  315.   caddr_t clientData;
  316.   dinoCallbackStruct *callData;
  317. {
  318.   int mode;
  319.   Boolean orient, practice, start;
  320.   Widget otherw;
  321.  
  322.   if (w == dino2d)
  323.     otherw = dino3d;
  324.   else /* (w == dino3d) */
  325.     otherw = dino2d;
  326.   XtVaGetValues(w,
  327.     XtNorient, &orient,
  328.     XtNmode, &mode,
  329.     XtNpractice, &practice,
  330.     XtNstart, &start,
  331.     NULL);
  332.   (void) strcpy(messageDsp, "");
  333.   switch (callData->reason) {
  334.     case DINO_RESTORE:
  335.       XtSetArg(arg[0], XtNdirection, DINO_RESTORE);
  336.       XtSetValues(otherw, arg, 1);
  337.       XtSetValues(w, arg, 1);
  338.       movesDsp = 0;
  339.       break;
  340.     case DINO_RESET:
  341.       movesDsp = 0;
  342.       break;
  343.     case DINO_ILLEGAL:
  344.       if (practice || start)
  345.         (void) strcpy(messageDsp, "Illegal move");
  346.       else
  347.         (void) strcpy(messageDsp, "Randomize to start");
  348.       break;
  349.     case DINO_MOVED:
  350.       movesDsp++;
  351.       XtSetArg(arg[0], XtNstart, TRUE);
  352.       XtSetArg(arg[1], XtNface, callData->face);
  353.       XtSetArg(arg[2], XtNpos, callData->position);
  354.       XtSetArg(arg[3], XtNdirection, callData->direction);
  355.       XtSetArg(arg[4], XtNstyle, callData->style);
  356.       XtSetValues(otherw, arg, 5);
  357.       XtSetValues(w, arg, 1);
  358.       break;
  359.     case DINO_CONTROL:
  360.       XtSetArg(arg[0], XtNface, callData->face);
  361.       XtSetArg(arg[1], XtNpos, callData->position);
  362.       XtSetArg(arg[2], XtNdirection, callData->direction);
  363.       XtSetArg(arg[3], XtNstyle, callData->style);
  364.       XtSetValues(otherw, arg, 4);
  365.       return;
  366.     case DINO_SOLVED:
  367.       if (practice)
  368.         movesDsp = 0;
  369.       else { 
  370.         if (HandleSolved(movesDsp, mode, orient))
  371.           (void) sprintf(messageDsp, "Congratulations %s!!", getlogin());
  372.         else
  373.           (void) strcpy(messageDsp, "Solved!");
  374.       }
  375.       XtSetArg(arg[0], XtNstart, FALSE);
  376.       XtSetValues(w, arg, 1);
  377.       XtSetValues(otherw, arg, 1);
  378.       break;
  379.     case DINO_PRACTICE:
  380.       movesDsp = 0;
  381.       practice = !practice;
  382.       if (!practice)
  383.         (void) strcpy(messageDsp, "Randomize to start");
  384.       PrintRecord(mode, orient, practice);
  385.       XtSetArg(arg[0], XtNpractice, practice);
  386.       XtSetArg(arg[1], XtNstart, FALSE);
  387.       XtSetValues(w, arg, 2);
  388.       XtSetValues(otherw, arg, 2);
  389.       XmToggleButtonSetState(practiceSwitch, practice, True);
  390.       break;
  391.     case DINO_RANDOMIZE:
  392.       movesDsp = 0;
  393.       XtSetArg(arg[0], XtNpractice, FALSE);
  394.       XtSetArg(arg[1], XtNstart, FALSE);
  395.       XtSetValues(w, arg, 2);
  396.       XtSetValues(otherw, arg, 2);
  397.       break; 
  398.     case DINO_ORIENT:
  399.       movesDsp = 0;
  400.       orient = !orient;
  401.       PrintRecord(mode, orient, practice);
  402.       XtSetArg(arg[0], XtNorient, orient);
  403.       XtSetValues(w, arg, 1);
  404.       XtSetValues(otherw, arg, 1);
  405.       XmToggleButtonSetState(orientSwitch, orient, True);
  406.       break;
  407.     case DINO_PERIOD2:
  408.     case DINO_PERIOD3:
  409.     case DINO_BOTH:
  410.       movesDsp = 0;
  411.       mode = callData->reason - DINO_PERIOD2 + PERIOD2;
  412.       PrintRecord(mode, orient, practice);
  413.       XtSetArg(arg[0], XtNmode, mode);
  414.       XtSetValues(w, arg, 1);
  415.       XtSetValues(otherw, arg, 1);
  416.       XmToggleButtonSetState(modes[mode - PERIOD2], True, True);
  417.       break;
  418.     case DINO_COMPUTED:
  419.       XtSetArg(arg[0], XtNstart, FALSE);
  420.       XtSetValues(w, arg, 1);
  421.       XtSetValues(otherw, arg, 1);
  422.       break;
  423.     case DINO_UNDO:
  424.       movesDsp--;
  425.       XtSetArg(arg[0], XtNstart, TRUE);
  426.       XtSetArg(arg[1], XtNface, callData->face);
  427.       XtSetArg(arg[2], XtNpos, callData->position);
  428.       XtSetArg(arg[3], XtNdirection, callData->direction);
  429.       XtSetArg(arg[4], XtNstyle, callData->style);
  430.       XtSetValues(otherw, arg, 5);
  431.       XtSetValues(w, arg, 1);
  432.       break;
  433.   }
  434.   motif_printf(message, "%s", messageDsp);
  435.   motif_printf(moves, "%d", movesDsp);
  436. }
  437.  
  438. static void ModeToggle(w, mode, cbs)
  439.   Widget w;
  440.   int mode;
  441.   XmToggleButtonCallbackStruct *cbs;
  442. {
  443.   Boolean orient, practice;
  444.  
  445.   if (cbs->set) {
  446.      XtVaGetValues(dino2d,
  447.       XtNorient, &orient,
  448.       XtNpractice, &practice,
  449.       NULL);
  450.     XtVaSetValues(dino2d,
  451.       XtNmode, mode + PERIOD2,
  452.       NULL);
  453.     XtVaSetValues(dino3d,
  454.       XtNmode, mode + PERIOD2,
  455.       NULL);
  456.     movesDsp = 0;
  457.     motif_printf(moves, "%d", movesDsp);
  458.     PrintRecord(mode + PERIOD2, orient, practice);
  459.   }
  460. }
  461.  
  462. static void OrientToggle(w, clientData, cbs)
  463.   Widget w;
  464.   XtPointer clientData;
  465.   XmToggleButtonCallbackStruct *cbs;
  466. {
  467.   int mode;
  468.   Boolean orient = cbs->set, practice;
  469.  
  470.   XtVaGetValues(dino2d,
  471.     XtNmode, &mode,
  472.     XtNpractice, &practice,
  473.     NULL);
  474.   XtVaSetValues(dino2d,
  475.     XtNorient, orient,
  476.     NULL);
  477.   XtVaSetValues(dino3d,
  478.     XtNorient, orient,
  479.     NULL);
  480.   movesDsp = 0;
  481.   motif_printf(moves, "%d", movesDsp);
  482.   PrintRecord(mode, orient, practice);
  483. }
  484.  
  485. static void PracticeToggle(w, clientData, cbs)
  486.   Widget w;
  487.   XtPointer clientData;
  488.   XmToggleButtonCallbackStruct *cbs;
  489. {
  490.   int mode;
  491.   Boolean orient, practice = cbs->set;
  492.  
  493.   XtVaSetValues(dino2d,
  494.     XtNpractice, practice,
  495.     XtNstart, FALSE,
  496.     NULL);
  497.   XtVaSetValues(dino3d,
  498.     XtNpractice, practice,
  499.     XtNstart, FALSE,
  500.     NULL);
  501.   XtVaGetValues(dino2d,
  502.     XtNmode, &mode,
  503.     XtNpractice, &orient,
  504.     NULL);
  505.   movesDsp = 0;
  506.   motif_printf(moves, "%d", movesDsp);
  507.   if (!practice)
  508.     (void) strcpy(messageDsp, "Randomize to start");
  509.   PrintRecord(mode, orient, practice);
  510. }
  511.  
  512. static void PrintRecord(mode, orient, practice)
  513.   int mode;
  514.   Boolean orient, practice;
  515. {
  516.   int i = mode - PERIOD2;
  517.   int j = (orient) ? 1 : 0;
  518.  
  519.   if (practice)
  520.     motif_printf(record, "practice");
  521.   else if (dinoRecord[i][j] >= MAXRECORD)
  522.     motif_printf(record, "NEVER");
  523.   else
  524.     motif_printf(record, "%d", dinoRecord[i][j]);
  525. }
  526.  
  527. static int HandleSolved(counter, mode, orient)
  528.   int counter, mode;
  529.   Boolean orient;
  530. {
  531.   int i = mode - PERIOD2;
  532.   int j = (orient) ? 1 : 0;
  533.  
  534.   if (counter < dinoRecord[i][j]) {
  535.     dinoRecord[i][j] = counter;
  536.     if (orient && (dinoRecord[i][j] < dinoRecord[!i][j]))
  537.       dinoRecord[!i][j] = counter;
  538.     WriteRecords();
  539.     PrintRecord(mode, orient, FALSE);
  540.     return TRUE;
  541.   }
  542.   return FALSE;
  543. }
  544.  
  545. static void ReadRecords()
  546. {
  547.   FILE *fp;
  548.   int n, mode, orient;
  549.  
  550.   for (mode = 0; mode < MAXMODES; mode++)
  551.     for (orient = 0; orient < 2; orient++)
  552.       dinoRecord[mode][orient] = MAXRECORD;
  553.   if ((fp = fopen(SCOREFILE, "r")) == NULL)
  554.     motif_printf(message, "Can not open %s, taking defaults.", SCOREFILE);
  555.   else {
  556.     for (mode = 0; mode < MAXMODES; mode++)
  557.       for (orient = 0; orient < 2; orient++) {
  558.         (void) fscanf(fp, "%d", &n);
  559.         dinoRecord[mode][orient] = n;
  560.       }
  561.     (void) fclose(fp);
  562.   }
  563. }
  564.  
  565. static void WriteRecords()
  566. {
  567.   FILE *fp;
  568.   int mode, orient;
  569.  
  570.   if ((fp = fopen(SCOREFILE, "w")) == NULL)
  571.     motif_printf(message, "Can not write to %s.", SCOREFILE);
  572.   else {
  573.     for (mode = 0; mode < MAXMODES; mode++) {
  574.       for (orient = 0; orient < 2; orient++)
  575.         (void) fprintf(fp, "%d ", dinoRecord[mode][orient]);
  576.       (void) fprintf(fp, "\n");
  577.     }
  578.     (void) fclose(fp);
  579.   }
  580. }
  581.  
  582. #include <varargs.h>
  583. static void motif_printf(va_alist)
  584.   va_dcl
  585. {
  586.   Widget w;
  587.   char *format;
  588.   va_list args;
  589.   char str[1000];
  590.   Arg wargs[10];
  591.   XmString xmstr;
  592.  
  593.   va_start(args);
  594.   w = va_arg(args, Widget);
  595.   if (!XtIsSubclass(w, xmLabelWidgetClass))
  596.     XtError("motif_printf() requires a Label Widget");
  597.   format = va_arg(args, char *);
  598.   (void) vsprintf(str, format, args);
  599.   xmstr = XmStringCreateLtoR(str, XmSTRING_DEFAULT_CHARSET);
  600.   XtSetArg(wargs[0], XmNlabelString, xmstr);
  601.   XtSetValues(w, wargs, 1);
  602.   va_end(args);
  603. }
  604.